टेम्पलेट लिटरल टाइप्स: टाइपस्क्रिप्ट में स्ट्रिंग पैटर्न मैचिंग और वैलिडेशन

टाइपस्क्रिप्ट का टाइप सिस्टम लगातार विकसित हो रहा है, जो डेवलपर्स को जटिल लॉजिक व्यक्त करने और टाइप सेफ्टी सुनिश्चित करने के लिए अधिक शक्तिशाली उपकरण प्रदान करता है। हाल के संस्करणों में पेश की गई सबसे दिलचस्प और बहुमुखी विशेषताओं में से एक टेम्पलेट लिटरल टाइप्स है। ये टाइप्स आपको टाइप लेवल पर स्ट्रिंग्स को मैनिपुलेट करने की अनुमति देते हैं, जिससे उन्नत स्ट्रिंग पैटर्न मैचिंग और वैलिडेशन संभव होता है। यह अधिक मजबूत और मेंटेनेबल एप्लिकेशन बनाने के लिए संभावनाओं की एक पूरी नई दुनिया खोलता है।

टेम्पलेट लिटरल टाइप्स क्या हैं?

टेम्पलेट लिटरल टाइप्स एक प्रकार के टाइप होते हैं जो स्ट्रिंग लिटरल टाइप्स और यूनियन टाइप्स को मिलाकर बनाए जाते हैं, ठीक उसी तरह जैसे जावास्क्रिप्ट में टेम्पलेट लिटरल्स काम करते हैं। हालाँकि, रनटाइम स्ट्रिंग्स बनाने के बजाय, वे मौजूदा टाइप्स के आधार पर नए टाइप्स बनाते हैं।

यहाँ एक बुनियादी उदाहरण है:

            type Greeting<T extends string> = `Hello, ${T}!`;

type MyGreeting = Greeting<"World">; // type MyGreeting = "Hello, World!"

            

              
                Copy
              
            
          

इस उदाहरण में, `Greeting` एक टेम्पलेट लिटरल टाइप है जो एक स्ट्रिंग टाइप `T` को इनपुट के रूप में लेता है और एक नया टाइप लौटाता है जो "Hello, ", `T`, और "!" का संयोजन है।

बेसिक स्ट्रिंग पैटर्न मैचिंग

टेम्पलेट लिटरल टाइप्स का उपयोग बेसिक स्ट्रिंग पैटर्न मैचिंग करने के लिए किया जा सकता है। यह आपको ऐसे टाइप्स बनाने की अनुमति देता है जो केवल तभी मान्य होते हैं जब वे एक निश्चित पैटर्न से मेल खाते हैं।

उदाहरण के लिए, आप एक ऐसा टाइप बना सकते हैं जो केवल "prefix-" से शुरू होने वाले स्ट्रिंग्स को स्वीकार करता है:

            type PrefixedString<T extends string> = T extends `prefix-${string}` ? T : never;

type ValidPrefixedString = PrefixedString<"prefix-valid">; // type ValidPrefixedString = "prefix-valid"
type InvalidPrefixedString = PrefixedString<"invalid">; // type InvalidPrefixedString = never

            

              
                Copy
              
            
          

इस उदाहरण में, `PrefixedString` यह जांचने के लिए एक कंडीशनल टाइप का उपयोग करता है कि इनपुट स्ट्रिंग `T` "prefix-" से शुरू होता है या नहीं। यदि ऐसा होता है, तो टाइप `T` ही होता है; अन्यथा, यह `never` होता है। `never` टाइपस्क्रिप्ट में एक विशेष टाइप है जो उन मानों के टाइप का प्रतिनिधित्व करता है जो कभी नहीं होते हैं, जो प्रभावी रूप से अमान्य स्ट्रिंग को बाहर कर देता है।

स्ट्रिंग के हिस्सों को निकालना

टेम्पलेट लिटरल टाइप्स का उपयोग स्ट्रिंग के हिस्सों को निकालने के लिए भी किया जा सकता है। यह विशेष रूप से तब उपयोगी होता है जब आपको स्ट्रिंग्स से डेटा पार्स करने और इसे विभिन्न प्रकारों में बदलने की आवश्यकता होती है।

मान लीजिए आपके पास एक स्ट्रिंग है जो "x:10,y:20" प्रारूप में एक कोऑर्डिनेट का प्रतिनिधित्व करती है। आप x और y मानों को निकालने के लिए टेम्पलेट लिटरल टाइप्स का उपयोग कर सकते हैं:

            type CoordinateString = `x:${number},y:${number}`;

type ExtractX<T extends CoordinateString> = T extends `x:${infer X},y:${number}` ? X : never;
type ExtractY<T extends CoordinateString> = T extends `x:${number},y:${infer Y}` ? Y : never;

type XValue = ExtractX<"x:10,y:20">; // type XValue = 10
type YValue = ExtractY<"x:10,y:20">; // type YValue = 20

            

              
                Copy
              
            
          

इस उदाहरण में, `ExtractX` और `ExtractY` `number` टाइप से मेल खाने वाले स्ट्रिंग के हिस्सों को कैप्चर करने के लिए `infer` कीवर्ड का उपयोग करते हैं। `infer` आपको एक पैटर्न मैच से एक टाइप निकालने की अनुमति देता है। कैप्चर किए गए टाइप्स को फिर कंडीशनल टाइप के रिटर्न टाइप के रूप में उपयोग किया जाता है।

एडवांस्ड स्ट्रिंग वैलिडेशन

एडवांस्ड स्ट्रिंग वैलिडेशन करने के लिए टेम्पलेट लिटरल टाइप्स को अन्य टाइपस्क्रिप्ट सुविधाओं, जैसे यूनियन टाइप्स और कंडीशनल टाइप्स के साथ जोड़ा जा सकता है। यह आपको ऐसे टाइप्स बनाने की अनुमति देता है जो स्ट्रिंग्स की संरचना और सामग्री पर जटिल नियम लागू करते हैं।

उदाहरण के लिए, आप एक ऐसा टाइप बना सकते हैं जो ISO 8601 दिनांक स्ट्रिंग्स को मान्य करता है:

            type Year = `${number}${number}${number}${number}`;
type Month = `0${number}` | `10` | `11` | `12`;
type Day = `${0}${number}` | `${1 | 2}${number}` | `30` | `31`;

type ISODate = `${Year}-${Month}-${Day}`;

type ValidDate = ISODate extends "2023-10-27" ? true : false; // true
type InvalidDate = ISODate extends "2023-13-27" ? true : false; // false

function processDate(date: ISODate) {
  // Function logic here.  TypeScript enforces the ISODate format.
  return `Processing date: ${date}`;
}

console.log(processDate("2024-01-15")); // Works
//console.log(processDate("2024-1-15")); // TypeScript error: Argument of type '"2024-1-15"' is not assignable to parameter of type '`${number}${number}${number}${number}-${0}${number}-${0}${number}` | `${number}${number}${number}${number}-${0}${number}-${1}${number}` | ... 14 more ... | `${number}${number}${number}${number}-12-31`'.

            

              
                Copy
              
            
          

यहां, `Year`, `Month`, और `Day` को दिनांक के प्रत्येक भाग के लिए मान्य प्रारूपों का प्रतिनिधित्व करने के लिए टेम्पलेट लिटरल टाइप्स का उपयोग करके परिभाषित किया गया है। `ISODate` फिर इन टाइप्स को मिलाकर एक ऐसा टाइप बनाता है जो एक मान्य ISO 8601 दिनांक स्ट्रिंग का प्रतिनिधित्व करता है। उदाहरण यह भी दर्शाता है कि इस टाइप का उपयोग किसी फ़ंक्शन में डेटा स्वरूपण को लागू करने के लिए कैसे किया जा सकता है, जिससे गलत दिनांक प्रारूपों को पास होने से रोका जा सकता है। यह कोड की विश्वसनीयता में सुधार करता है और अमान्य इनपुट के कारण होने वाली रनटाइम त्रुटियों को रोकता है।

वास्तविक दुनिया के उपयोग के मामले

टेम्पलेट लिटरल टाइप्स का उपयोग विभिन्न प्रकार के वास्तविक दुनिया के परिदृश्यों में किया जा सकता है। यहाँ कुछ उदाहरण दिए गए हैं:

• फ़ॉर्म वैलिडेशन: आप फ़ॉर्म इनपुट के प्रारूप को मान्य करने के लिए टेम्पलेट लिटरल टाइप्स का उपयोग कर सकते हैं, जैसे ईमेल पते, फ़ोन नंबर और पोस्टल कोड।
• API रिक्वेस्ट वैलिडेशन: आप API रिक्वेस्ट पेलोड की संरचना को मान्य करने के लिए टेम्पलेट लिटरल टाइप्स का उपयोग कर सकते हैं, यह सुनिश्चित करते हुए कि वे अपेक्षित प्रारूप के अनुरूप हैं। उदाहरण के लिए, एक करेंसी कोड (जैसे, "USD", "EUR", "GBP") को मान्य करना।
• कॉन्फ़िगरेशन फ़ाइल पार्सिंग: आप कॉन्फ़िगरेशन फ़ाइलों को पार्स करने और विशिष्ट पैटर्न के आधार पर मान निकालने के लिए टेम्पलेट लिटरल टाइप्स का उपयोग कर सकते हैं। एक कॉन्फ़िगरेशन ऑब्जेक्ट में फ़ाइल पाथ को मान्य करने पर विचार करें।
• स्ट्रिंग-आधारित एनम्स: आप टेम्पलेट लिटरल टाइप्स का उपयोग करके वैलिडेशन के साथ स्ट्रिंग-आधारित एनम्स बना सकते हैं।

उदाहरण: करेंसी कोड मान्य करना

आइए करेंसी कोड को मान्य करने का एक अधिक विस्तृत उदाहरण देखें। हम यह सुनिश्चित करना चाहते हैं कि हमारे एप्लिकेशन में केवल मान्य ISO 4217 करेंसी कोड का उपयोग किया जाए। ये कोड आमतौर पर तीन बड़े अक्षरों के होते हैं।

            type CurrencyCode = `${Uppercase<string>}${Uppercase<string>}${Uppercase<string>}`;

function formatCurrency(amount: number, currency: CurrencyCode) {
  // Function logic to format currency based on the provided code.
  return `$${amount} ${currency}`;
}

console.log(formatCurrency(100, "USD")); // Works
//console.log(formatCurrency(100, "usd")); // TypeScript error: Argument of type '"usd"' is not assignable to parameter of type '`${Uppercase<string>}${Uppercase<string>}${Uppercase<string>}`'.

//More precise example:
type ValidCurrencyCode = "USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"; // Extend as needed

type StronglyTypedCurrencyCode = ValidCurrencyCode;

function formatCurrencyStronglyTyped(amount: number, currency: StronglyTypedCurrencyCode) {
    return `$${amount} ${currency}`;
}

console.log(formatCurrencyStronglyTyped(100, "EUR")); // Works
//console.log(formatCurrencyStronglyTyped(100, "CNY")); // TypeScript error: Argument of type '"CNY"' is not assignable to parameter of type '"USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"'.

            

              
                Copy
              
            
          

यह उदाहरण दिखाता है कि कैसे एक `CurrencyCode` टाइप बनाया जाए जो केवल तीन बड़े अक्षरों वाले स्ट्रिंग्स को स्वीकार करता है। दूसरा, अधिक स्ट्रॉन्गली-टाइप्ड उदाहरण दिखाता है कि इसे स्वीकार्य करेंसियों की एक पूर्व-निर्धारित सूची तक और कैसे सीमित किया जाए।

उदाहरण: API एंडपॉइंट पाथ को मान्य करना

एक और उपयोग का मामला API एंडपॉइंट पाथ को मान्य करना है। आप एक ऐसा टाइप परिभाषित कर सकते हैं जो एक मान्य API एंडपॉइंट संरचना का प्रतिनिधित्व करता है, यह सुनिश्चित करते हुए कि अनुरोध सही पाथ पर किए गए हैं। यह विशेष रूप से माइक्रोसर्विसेज आर्किटेक्चर में उपयोगी है जहां कई सेवाएं विभिन्न API को एक्सपोज कर सकती हैं।

            type APIServiceName = "users" | "products" | "orders";
type APIEndpointPath = `/${APIServiceName}/${string}`;

function callAPI(path: APIEndpointPath) {
  // API call logic
  console.log(`Calling API: ${path}`);
}

callAPI("/users/123"); // Valid
callAPI("/products/details"); // Valid
//callAPI("/invalid/path"); // TypeScript error

// Even more specific:
type APIAction = "create" | "read" | "update" | "delete";
type APIEndpointPathSpecific = `/${APIServiceName}/${APIAction}`;

function callAPISpecific(path: APIEndpointPathSpecific) {
  // API call logic
  console.log(`Calling specific API: ${path}`);
}

callAPISpecific("/users/create"); // Valid
//callAPISpecific("/users/list"); // TypeScript error

            

              
                Copy
              
            
          

यह आपको API एंडपॉइंट्स की संरचना को अधिक सटीक रूप से परिभाषित करने की अनुमति देता है, जिससे टाइपो को रोका जा सकता है और आपके एप्लिकेशन में स्थिरता सुनिश्चित होती है। यह एक बुनियादी उदाहरण है; URL के क्वेरी पैरामीटर और अन्य भागों को मान्य करने के लिए और अधिक जटिल पैटर्न बनाए जा सकते हैं।

टेम्पलेट लिटरल टाइप्स का उपयोग करने के लाभ

टेम्पलेट लिटरल टाइप्स का उपयोग स्ट्रिंग पैटर्न मैचिंग और वैलिडेशन के लिए करने से कई लाभ मिलते हैं:

• बेहतर टाइप सेफ्टी: टेम्पलेट लिटरल टाइप्स आपको स्ट्रिंग्स पर सख्त टाइप बाधाएं लागू करने की अनुमति देते हैं, जिससे रनटाइम त्रुटियों का खतरा कम हो जाता है।
• बढ़ी हुई कोड पठनीयता: टेम्पलेट लिटरल टाइप्स स्ट्रिंग्स के अपेक्षित प्रारूप को स्पष्ट रूप से व्यक्त करके आपके कोड को अधिक पठनीय बनाते हैं।
• बढ़ी हुई मेंटेनेबिलिटी: टेम्पलेट लिटरल टाइप्स स्ट्रिंग वैलिडेशन नियमों के लिए सत्य का एक ही स्रोत प्रदान करके आपके कोड को अधिक मेंटेनेबल बनाते हैं।
• बेहतर डेवलपर अनुभव: टेम्पलेट लिटरल टाइप्स बेहतर ऑटोकंप्लीशन और त्रुटि संदेश प्रदान करते हैं, जिससे समग्र डेवलपर अनुभव में सुधार होता है।

सीमाएं

हालांकि टेम्पलेट लिटरल टाइप्स शक्तिशाली हैं, उनकी कुछ सीमाएं भी हैं:

• जटिलता: टेम्पलेट लिटरल टाइप्स जटिल हो सकते हैं, खासकर जब जटिल पैटर्न से निपटना हो। टाइप सेफ्टी के लाभों को कोड मेंटेनेबिलिटी के साथ संतुलित करना महत्वपूर्ण है।
• प्रदर्शन: टेम्पलेट लिटरल टाइप्स संकलन प्रदर्शन को प्रभावित कर सकते हैं, खासकर बड़े प्रोजेक्ट्स में। ऐसा इसलिए है क्योंकि टाइपस्क्रिप्ट को अधिक जटिल टाइप चेकिंग करने की आवश्यकता होती है।
• सीमित रेगुलर एक्सप्रेशन सपोर्ट: जबकि टेम्पलेट लिटरल टाइप्स पैटर्न मैचिंग की अनुमति देते हैं, वे रेगुलर एक्सप्रेशन सुविधाओं की पूरी श्रृंखला का समर्थन नहीं करते हैं। अत्यधिक जटिल स्ट्रिंग वैलिडेशन के लिए, उचित इनपुट सैनिटाइजेशन के लिए इन टाइप कंस्ट्रक्ट्स के साथ-साथ रनटाइम रेगुलर एक्सप्रेशन की अभी भी आवश्यकता हो सकती है।

सर्वोत्तम प्रथाएं

यहां कुछ सर्वोत्तम प्रथाएं दी गई हैं जिन्हें टेम्पलेट लिटरल टाइप्स का उपयोग करते समय ध्यान में रखना चाहिए:

• सरल शुरुआत करें: सरल पैटर्न से शुरू करें और आवश्यकतानुसार धीरे-धीरे जटिलता बढ़ाएं।
• वर्णनात्मक नामों का उपयोग करें: कोड पठनीयता में सुधार के लिए अपने टेम्पलेट लिटरल टाइप्स के लिए वर्णनात्मक नामों का उपयोग करें।
• अपने टाइप्स का दस्तावेजीकरण करें: अपने टेम्पलेट लिटरल टाइप्स के उद्देश्य और उपयोग की व्याख्या करने के लिए उनका दस्तावेजीकरण करें।
• पूरी तरह से परीक्षण करें: यह सुनिश्चित करने के लिए कि वे अपेक्षित रूप से व्यवहार करते हैं, अपने टेम्पलेट लिटरल टाइप्स का पूरी तरह से परीक्षण करें।
• प्रदर्शन पर विचार करें: संकलन प्रदर्शन पर टेम्पलेट लिटरल टाइप्स के प्रभाव के प्रति सचेत रहें और अपने कोड को तदनुसार अनुकूलित करें।

निष्कर्ष

टेम्पलेट लिटरल टाइप्स टाइपस्क्रिप्ट में एक शक्तिशाली सुविधा है जो आपको टाइप लेवल पर उन्नत स्ट्रिंग मैनिपुलेशन, पैटर्न मैचिंग और वैलिडेशन करने की अनुमति देती है। टेम्पलेट लिटरल टाइप्स का उपयोग करके, आप अधिक मजबूत, मेंटेनेबल और टाइप-सेफ एप्लिकेशन बना सकते हैं। जबकि उनकी कुछ सीमाएं हैं, टेम्पलेट लिटरल टाइप्स का उपयोग करने के लाभ अक्सर कमियों से अधिक होते हैं, जो उन्हें किसी भी टाइपस्क्रिप्ट डेवलपर के शस्त्रागार में एक मूल्यवान उपकरण बनाते हैं। जैसे-जैसे टाइपस्क्रिप्ट भाषा विकसित होती रहेगी, उच्च-गुणवत्ता वाले सॉफ़्टवेयर बनाने के लिए इन उन्नत टाइप सुविधाओं को समझना और उपयोग करना महत्वपूर्ण होगा। जटिलता को पठनीयता के साथ संतुलित करना और हमेशा संपूर्ण परीक्षण को प्राथमिकता देना याद रखें।